map

type map<K: -immutable, V> : iterable<(K, V)>

A mutable map from keys of type K to values of type V, where K is immutable, and V may be either mutable or immutable. map<K,V> is a subtype of iterable<(K,V)>`. It is implemented as a hash-map, with iteration order determined by the order in which the entries were added.

Since

0.6.0

Constructors

map

pure constructor()

Construct a new empty map.

pure constructor(entries: iterable<-map_entry<K,V>>)

Construct a new map by copying the entries from another iterable. The provided entries are an iterable with element type map_entry<K,V>; a supertype of the two-element tuple (K,V).

Functions

clear

function clear()

Clear this map; i.e. remove all its entries. Immediately after this method returns, this map is empty.

contains

pure function contains(key: K): boolean

Check if this map contains the given key.

empty

pure function empty(): boolean

Check if this map is empty.

get

pure function get(key: K): V

Get the value associated with the given key in this map.

get_or_default

pure function <R: +V> get_or_default(key: K, default: R): R

Get the value associated with the given key in this map.

get_or_null

pure function get_or_null(key: K): V?

Get the value associated with the given key in this map.

join_to_text

pure function join_to_text([separator: text], [prefix: text], [postfix: text], [limit: integer?], [truncated: text], [transform: ((K, V)) -> text]): text

Generate a textual representation of this iterable.

An optional separator, prefix and postfix can be provided. One can also provide a limit: integer?. If there are more elements in the result than limit, the elements whose indices exceed limit are omitted, and the passed truncated: text is included instead.

Examples:

[1, 2, 3].join_to_text() returns '1, 2, 3'.
[1, 2, 3].join_to_text('_') returns '1_2_3'.
[1, 2, 3].join_to_text('*', '(', ')') returns '(1*2*3)'.
list<T>().join_to_text('!', '(', ')') returns '()' (where T is a valid type).
range(10).join_to_text('', '', '', 5) returns '01234...'.
range(10).join_to_text('', '', '', 5, 'more') returns '01234more'.

Where the function even is defined:

function even(x: integer): text {
   return if (x % 2 == 0) 'EVEN' else 'ODD';
}

Then:

range(10).join_to_text('->', '{', '}', 5, '...', even(*)) returns {EVEN->ODD->EVEN->ODD->EVEN->...}.

keys

pure function keys(): set<K>

Returns a set containing the keys of this map.

Examples:

[1: 'a', 2: 'b', 3: 'c'].keys() returns set([1, 2, 3]).
map<K,V>().keys() returns set() (where K and V are valid types).

len

(alias) pure function ~~len~~(): integer

Get the size (number of entries) of this map.

Alias

size

put

function put(key: K, value: V)

Associate the specified value with the specified key in this map.

put_all

function put_all(map: map<-K, -V>)

Update this map with the entries from another map. Where a key is found in both this and the passed map, the corresponding value in the passed map overwrites the value in this map. In other words, this is a right-biased operation.

put_all_copy

function put_all_copy(map: map<-K, -V>): map<K, V>

Returns a new map with the mappings of this map combined with the mappings of the given map.

Where a value exists for a given key in both this and the other map, the returned map has the value of the other map, as opposed to the value in this map (right-biased).

a.put_all_copy(b) is equivalent to a + b, where a and b are both maps.

Examples:

[1: 'a', 2: 'b', 3: 'c'].put_all_copy([1: 'Z', 4: 'd', 5: 'e']) returns [1: 'Z', 2: 'b', 3: 'c', 4: 'd', 5: 'e']
[1: 'a', 2: 'b', 3: 'c'].put_all_copy([4: 'd', 5: 'e']) returns [1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e']